define("ace/ext/menu_tools/overlay_page", ["require", "exports", "module", "ace/lib/dom"], function (require, exports, module) {
    'use strict';
    var dom = require("../../lib/dom");
    var cssText = "#ace_settingsmenu, #kbshortcutmenu {\
    background-color: #F7F7F7;\
    color: black;\
    box-shadow: -5px 4px 5px rgba(126, 126, 126, 0.55);\
    padding: 1em 0.5em 2em 1em;\
    overflow: auto;\
    position: absolute;\
    margin: 0;\
    bottom: 0;\
    right: 0;\
    top: 0;\
    z-index: 9991;\
    cursor: default;\
    }\
    .ace_dark #ace_settingsmenu, .ace_dark #kbshortcutmenu {\
    box-shadow: -20px 10px 25px rgba(126, 126, 126, 0.25);\
    background-color: rgba(255, 255, 255, 0.6);\
    color: black;\
    }\
    .ace_optionsMenuEntry:hover {\
    background-color: rgba(100, 100, 100, 0.1);\
    transition: all 0.3s\
    }\
    .ace_closeButton {\
    background: rgba(245, 146, 146, 0.5);\
    border: 1px solid #F48A8A;\
    border-radius: 50%;\
    padding: 7px;\
    position: absolute;\
    right: -8px;\
    top: -8px;\
    z-index: 100000;\
    }\
    .ace_closeButton{\
    background: rgba(245, 146, 146, 0.9);\
    }\
    .ace_optionsMenuKey {\
    color: darkslateblue;\
    font-weight: bold;\
    }\
    .ace_optionsMenuCommand {\
    color: darkcyan;\
    font-weight: normal;\
    }\
    .ace_optionsMenuEntry input, .ace_optionsMenuEntry button {\
    vertical-align: middle;\
    }\
    .ace_optionsMenuEntry button[ace_selected_button=true] {\
    background: #e7e7e7;\
    box-shadow: 1px 0px 2px 0px #adadad inset;\
    border-color: #adadad;\
    }\
    .ace_optionsMenuEntry button {\
    background: white;\
    border: 1px solid lightgray;\
    margin: 0px;\
    }\
    .ace_optionsMenuEntry button:hover{\
    background: #f0f0f0;\
    }";
    dom.importCssString(cssText);

    module.exports.overlayPage = function overlayPage(editor, contentElement, callback) {
        var closer = document.createElement('div');
        var ignoreFocusOut = false;

        function documentEscListener(e) {
            if (e.keyCode === 27) {
                close();
            }
        }

        function close() {
            if (!closer) return;
            document.removeEventListener('keydown', documentEscListener);
            closer.parentNode.removeChild(closer);
            if (editor) {
                editor.focus();
            }
            closer = null;
            callback && callback();
        }

        function setIgnoreFocusOut(ignore) {
            ignoreFocusOut = ignore;
            if (ignore) {
                closer.style.pointerEvents = "none";
                contentElement.style.pointerEvents = "auto";
            }
        }

        closer.style.cssText = 'margin: 0; padding: 0; ' +
            'position: fixed; top:0; bottom:0; left:0; right:0;' +
            'z-index: 9990; ' +
            (editor ? 'background-color: rgba(0, 0, 0, 0.3);' : '');
        closer.addEventListener('click', function (e) {
            if (!ignoreFocusOut) {
                close();
            }
        });
        document.addEventListener('keydown', documentEscListener);

        contentElement.addEventListener('click', function (e) {
            e.stopPropagation();
        });

        closer.appendChild(contentElement);
        document.body.appendChild(closer);
        if (editor) {
            editor.blur();
        }
        return {
            close: close,
            setIgnoreFocusOut: setIgnoreFocusOut
        };
    };

});

define("ace/ext/modelist", ["require", "exports", "module"], function (require, exports, module) {
    "use strict";

    var modes = [];

    function getModeForPath(path) {
        var mode = modesByName.text;
        var fileName = path.split(/[\/\\]/).pop();
        for (var i = 0; i < modes.length; i++) {
            if (modes[i].supportsFile(fileName)) {
                mode = modes[i];
                break;
            }
        }
        return mode;
    }

    var Mode = function (name, caption, extensions) {
        this.name = name;
        this.caption = caption;
        this.mode = "ace/mode/" + name;
        this.extensions = extensions;
        var re;
        if (/\^/.test(extensions)) {
            re = extensions.replace(/\|(\^)?/g, function (a, b) {
                return "$|" + (b ? "^" : "^.*\\.");
            }) + "$";
        } else {
            re = "^.*\\.(" + extensions + ")$";
        }

        this.extRe = new RegExp(re, "gi");
    };

    Mode.prototype.supportsFile = function (filename) {
        return filename.match(this.extRe);
    };
    var supportedModes = {
        ABAP: ["abap"],
        ABC: ["abc"],
        ActionScript: ["as"],
        ADA: ["ada|adb"],
        Alda: ["alda"],
        Apache_Conf: ["^htaccess|^htgroups|^htpasswd|^conf|htaccess|htgroups|htpasswd"],
        Apex: ["apex|cls|trigger|tgr"],
        AQL: ["aql"],
        AsciiDoc: ["asciidoc|adoc"],
        ASL: ["dsl|asl"],
        Assembly_x86: ["asm|a"],
        AutoHotKey: ["ahk"],
        BatchFile: ["bat|cmd"],
        C_Cpp: ["cpp|c|cc|cxx|h|hh|hpp|ino"],
        C9Search: ["c9search_results"],
        Cirru: ["cirru|cr"],
        Clojure: ["clj|cljs"],
        Cobol: ["CBL|COB"],
        coffee: ["coffee|cf|cson|^Cakefile"],
        ColdFusion: ["cfm"],
        Crystal: ["cr"],
        CSharp: ["cs"],
        Csound_Document: ["csd"],
        Csound_Orchestra: ["orc"],
        Csound_Score: ["sco"],
        CSS: ["css"],
        Curly: ["curly"],
        D: ["d|di"],
        Dart: ["dart"],
        Diff: ["diff|patch"],
        Dockerfile: ["^Dockerfile"],
        Dot: ["dot"],
        Drools: ["drl"],
        Edifact: ["edi"],
        Eiffel: ["e|ge"],
        EJS: ["ejs"],
        Elixir: ["ex|exs"],
        Elm: ["elm"],
        Erlang: ["erl|hrl"],
        Forth: ["frt|fs|ldr|fth|4th"],
        Fortran: ["f|f90"],
        FSharp: ["fsi|fs|ml|mli|fsx|fsscript"],
        FSL: ["fsl"],
        FTL: ["ftl"],
        Gcode: ["gcode"],
        Gherkin: ["feature"],
        Gitignore: ["^.gitignore"],
        Glsl: ["glsl|frag|vert"],
        Gobstones: ["gbs"],
        golang: ["go"],
        GraphQLSchema: ["gql"],
        Groovy: ["groovy"],
        HAML: ["haml"],
        Handlebars: ["hbs|handlebars|tpl|mustache"],
        Haskell: ["hs"],
        Haskell_Cabal: ["cabal"],
        haXe: ["hx"],
        Hjson: ["hjson"],
        HTML: ["html|htm|xhtml|vue|we|wpy"],
        HTML_Elixir: ["eex|html.eex"],
        HTML_Ruby: ["erb|rhtml|html.erb"],
        INI: ["ini|conf|cfg|prefs"],
        Io: ["io"],
        Jack: ["jack"],
        Jade: ["jade|pug"],
        Java: ["java"],
        JavaScript: ["js|jsm|jsx"],
        JSON: ["json"],
        JSON5: ["json5"],
        JSONiq: ["jq"],
        JSP: ["jsp"],
        JSSM: ["jssm|jssm_state"],
        JSX: ["jsx"],
        Julia: ["jl"],
        Kotlin: ["kt|kts"],
        LaTeX: ["tex|latex|ltx|bib"],
        LESS: ["less"],
        Liquid: ["liquid"],
        Lisp: ["lisp"],
        LiveScript: ["ls"],
        LogiQL: ["logic|lql"],
        LSL: ["lsl"],
        Lua: ["lua"],
        LuaPage: ["lp"],
        Lucene: ["lucene"],
        Makefile: ["^Makefile|^GNUmakefile|^makefile|^OCamlMakefile|make"],
        Markdown: ["md|markdown"],
        Mask: ["mask"],
        MATLAB: ["matlab"],
        Maze: ["mz"],
        MediaWiki: ["wiki|mediawiki"],
        MEL: ["mel"],
        MIXAL: ["mixal"],
        MUSHCode: ["mc|mush"],
        MySQL: ["mysql"],
        Nginx: ["nginx|conf"],
        Nim: ["nim"],
        Nix: ["nix"],
        NSIS: ["nsi|nsh"],
        Nunjucks: ["nunjucks|nunjs|nj|njk"],
        ObjectiveC: ["m|mm"],
        OCaml: ["ml|mli"],
        Pascal: ["pas|p"],
        Perl: ["pl|pm"],
        Perl6: ["p6|pl6|pm6"],
        pgSQL: ["pgsql"],
        PHP: ["php|inc|phtml|shtml|php3|php4|php5|phps|phpt|aw|ctp|module"],
        PHP_Laravel_blade: ["blade.php"],
        Pig: ["pig"],
        Powershell: ["ps1"],
        Praat: ["praat|praatscript|psc|proc"],
        Prisma: ["prisma"],
        Prolog: ["plg|prolog"],
        Properties: ["properties"],
        Protobuf: ["proto"],
        Puppet: ["epp|pp"],
        Python: ["py"],
        QML: ["qml"],
        R: ["r"],
        Razor: ["cshtml|asp"],
        RDoc: ["Rd"],
        Red: ["red|reds"],
        RHTML: ["Rhtml"],
        RST: ["rst"],
        Ruby: ["rb|ru|gemspec|rake|^Guardfile|^Rakefile|^Gemfile"],
        Rust: ["rs"],
        SASS: ["sass"],
        SCAD: ["scad"],
        Scala: ["scala|sbt"],
        Scheme: ["scm|sm|rkt|oak|scheme"],
        SCSS: ["scss"],
        SH: ["sh|bash|^.bashrc"],
        SJS: ["sjs"],
        Slim: ["slim|skim"],
        Smarty: ["smarty|tpl"],
        snippets: ["snippets"],
        Soy_Template: ["soy"],
        Space: ["space"],
        SQL: ["sql"],
        SQLServer: ["sqlserver"],
        Stylus: ["styl|stylus"],
        SVG: ["svg"],
        Swift: ["swift"],
        Tcl: ["tcl"],
        Terraform: ["tf", "tfvars", "terragrunt"],
        Tex: ["tex"],
        Text: ["txt"],
        Textile: ["textile"],
        Toml: ["toml"],
        TSX: ["tsx"],
        Twig: ["latte|twig|swig"],
        Typescript: ["ts|typescript|str"],
        Vala: ["vala"],
        VBScript: ["vbs|vb"],
        Velocity: ["vm"],
        Verilog: ["v|vh|sv|svh"],
        VHDL: ["vhd|vhdl"],
        Visualforce: ["vfp|component|page"],
        Wollok: ["wlk|wpgm|wtest"],
        XML: ["xml|rdf|rss|wsdl|xslt|atom|mathml|mml|xul|xbl|xaml"],
        XQuery: ["xq"],
        YAML: ["yaml|yml"],
        Zeek: ["zeek|bro"],
        Django: ["html"]
    };

    var nameOverrides = {
        ObjectiveC: "Objective-C",
        CSharp: "C#",
        golang: "Go",
        C_Cpp: "C and C++",
        Csound_Document: "Csound Document",
        Csound_Orchestra: "Csound",
        Csound_Score: "Csound Score",
        coffee: "CoffeeScript",
        HTML_Ruby: "HTML (Ruby)",
        HTML_Elixir: "HTML (Elixir)",
        FTL: "FreeMarker",
        PHP_Laravel_blade: "PHP (Blade Template)",
        Perl6: "Perl 6",
        AutoHotKey: "AutoHotkey / AutoIt"
    };
    var modesByName = {};
    for (var name in supportedModes) {
        var data = supportedModes[name];
        var displayName = (nameOverrides[name] || name).replace(/_/g, " ");
        var filename = name.toLowerCase();
        var mode = new Mode(filename, displayName, data[0]);
        modesByName[filename] = mode;
        modes.push(mode);
    }

    module.exports = {
        getModeForPath: getModeForPath,
        modes: modes,
        modesByName: modesByName
    };

});

define("ace/ext/themelist", ["require", "exports", "module"], function (require, exports, module) {
    "use strict";

    var themeData = [
        ["Chrome"],
        ["Clouds"],
        ["Crimson Editor"],
        ["Dawn"],
        ["Dreamweaver"],
        ["Eclipse"],
        ["GitHub"],
        ["IPlastic"],
        ["Solarized Light"],
        ["TextMate"],
        ["Tomorrow"],
        ["Xcode"],
        ["Kuroir"],
        ["KatzenMilch"],
        ["SQL Server", "sqlserver", "light"],
        ["Ambiance", "ambiance", "dark"],
        ["Chaos", "chaos", "dark"],
        ["Clouds Midnight", "clouds_midnight", "dark"],
        ["Dracula", "", "dark"],
        ["Cobalt", "cobalt", "dark"],
        ["Gruvbox", "gruvbox", "dark"],
        ["Green on Black", "gob", "dark"],
        ["idle Fingers", "idle_fingers", "dark"],
        ["krTheme", "kr_theme", "dark"],
        ["Merbivore", "merbivore", "dark"],
        ["Merbivore Soft", "merbivore_soft", "dark"],
        ["Mono Industrial", "mono_industrial", "dark"],
        ["Monokai", "monokai", "dark"],
        ["Nord Dark", "nord_dark", "dark"],
        ["Pastel on dark", "pastel_on_dark", "dark"],
        ["Solarized Dark", "solarized_dark", "dark"],
        ["Terminal", "terminal", "dark"],
        ["Tomorrow Night", "tomorrow_night", "dark"],
        ["Tomorrow Night Blue", "tomorrow_night_blue", "dark"],
        ["Tomorrow Night Bright", "tomorrow_night_bright", "dark"],
        ["Tomorrow Night 80s", "tomorrow_night_eighties", "dark"],
        ["Twilight", "twilight", "dark"],
        ["Vibrant Ink", "vibrant_ink", "dark"]
    ];


    exports.themesByName = {};
    exports.themes = themeData.map(function (data) {
        var name = data[1] || data[0].replace(/ /g, "_").toLowerCase();
        var theme = {
            caption: data[0],
            theme: "ace/theme/" + name,
            isDark: data[2] == "dark",
            name: name
        };
        exports.themesByName[name] = theme;
        return theme;
    });

});

define("ace/ext/options", ["require", "exports", "module", "ace/ext/menu_tools/overlay_page", "ace/lib/dom", "ace/lib/oop", "ace/config", "ace/lib/event_emitter", "ace/ext/modelist", "ace/ext/themelist"], function (require, exports, module) {
    "use strict";

    require("./menu_tools/overlay_page");

    var dom = require("../lib/dom");
    var oop = require("../lib/oop");
    var config = require("../config");
    var EventEmitter = require("../lib/event_emitter").EventEmitter;
    var buildDom = dom.buildDom;

    var modelist = require("./modelist");
    var themelist = require("./themelist");

    var themes = {
        Bright: [],
        Dark: []
    };
    themelist.themes.forEach(function (x) {
        themes[x.isDark ? "Dark" : "Bright"].push({
            caption: x.caption,
            value: x.theme
        });
    });

    var modes = modelist.modes.map(function (x) {
        return {
            caption: x.caption,
            value: x.mode
        };
    });


    var optionGroups = {
        Main: {
            Mode: {
                path: "mode",
                type: "select",
                items: modes
            },
            Theme: {
                path: "theme",
                type: "select",
                items: themes
            },
            "Keybinding": {
                type: "buttonBar",
                path: "keyboardHandler",
                items: [{
                        caption: "Ace",
                        value: null
                    },
                    {
                        caption: "Vim",
                        value: "ace/keyboard/vim"
                    },
                    {
                        caption: "Emacs",
                        value: "ace/keyboard/emacs"
                    },
                    {
                        caption: "Sublime",
                        value: "ace/keyboard/sublime"
                    },
                    {
                        caption: "VSCode",
                        value: "ace/keyboard/vscode"
                    }
                ]
            },
            "Font Size": {
                path: "fontSize",
                type: "number",
                defaultValue: 12,
                defaults: [{
                        caption: "12px",
                        value: 12
                    },
                    {
                        caption: "24px",
                        value: 24
                    }
                ]
            },
            "Soft Wrap": {
                type: "buttonBar",
                path: "wrap",
                items: [{
                        caption: "Off",
                        value: "off"
                    },
                    {
                        caption: "View",
                        value: "free"
                    },
                    {
                        caption: "margin",
                        value: "printMargin"
                    },
                    {
                        caption: "40",
                        value: "40"
                    }
                ]
            },
            "Cursor Style": {
                path: "cursorStyle",
                items: [{
                        caption: "Ace",
                        value: "ace"
                    },
                    {
                        caption: "Slim",
                        value: "slim"
                    },
                    {
                        caption: "Smooth",
                        value: "smooth"
                    },
                    {
                        caption: "Smooth And Slim",
                        value: "smooth slim"
                    },
                    {
                        caption: "Wide",
                        value: "wide"
                    }
                ]
            },
            "Folding": {
                path: "foldStyle",
                items: [{
                        caption: "Manual",
                        value: "manual"
                    },
                    {
                        caption: "Mark begin",
                        value: "markbegin"
                    },
                    {
                        caption: "Mark begin and end",
                        value: "markbeginend"
                    }
                ]
            },
            "Soft Tabs": [{
                path: "useSoftTabs"
            }, {
                ariaLabel: "Tab Size",
                path: "tabSize",
                type: "number",
                values: [2, 3, 4, 8, 16]
            }],
            "Overscroll": {
                type: "buttonBar",
                path: "scrollPastEnd",
                items: [{
                        caption: "None",
                        value: 0
                    },
                    {
                        caption: "Half",
                        value: 0.5
                    },
                    {
                        caption: "Full",
                        value: 1
                    }
                ]
            }
        },
        More: {
            "Atomic soft tabs": {
                path: "navigateWithinSoftTabs"
            },
            "Enable Behaviours": {
                path: "behavioursEnabled"
            },
            "Wrap with quotes": {
                path: "wrapBehavioursEnabled"
            },
            "Enable Auto Indent": {
                path: "enableAutoIndent"
            },
            "Full Line Selection": {
                type: "checkbox",
                values: "text|line",
                path: "selectionStyle"
            },
            "Highlight Active Line": {
                path: "highlightActiveLine"
            },
            "Show Invisibles": {
                path: "showInvisibles"
            },
            "Show Indent Guides": {
                path: "displayIndentGuides"
            },
            "Persistent HScrollbar": {
                path: "hScrollBarAlwaysVisible"
            },
            "Persistent VScrollbar": {
                path: "vScrollBarAlwaysVisible"
            },
            "Animate scrolling": {
                path: "animatedScroll"
            },
            "Show Gutter": {
                path: "showGutter"
            },
            "Show Line Numbers": {
                path: "showLineNumbers"
            },
            "Relative Line Numbers": {
                path: "relativeLineNumbers"
            },
            "Fixed Gutter Width": {
                path: "fixedWidthGutter"
            },
            "Show Print Margin": [{
                path: "showPrintMargin"
            }, {
                ariaLabel: "Print Margin",
                type: "number",
                path: "printMarginColumn"
            }],
            "Indented Soft Wrap": {
                path: "indentedSoftWrap"
            },
            "Highlight selected word": {
                path: "highlightSelectedWord"
            },
            "Fade Fold Widgets": {
                path: "fadeFoldWidgets"
            },
            "Use textarea for IME": {
                path: "useTextareaForIME"
            },
            "Merge Undo Deltas": {
                path: "mergeUndoDeltas",
                items: [{
                        caption: "Always",
                        value: "always"
                    },
                    {
                        caption: "Never",
                        value: "false"
                    },
                    {
                        caption: "Timed",
                        value: "true"
                    }
                ]
            },
            "Elastic Tabstops": {
                path: "useElasticTabstops"
            },
            "Incremental Search": {
                path: "useIncrementalSearch"
            },
            "Read-only": {
                path: "readOnly"
            },
            "Copy without selection": {
                path: "copyWithEmptySelection"
            },
            "Live Autocompletion": {
                path: "enableLiveAutocompletion"
            }
        }
    };


    var OptionPanel = function (editor, element) {
        this.editor = editor;
        this.container = element || document.createElement("div");
        this.groups = [];
        this.options = {};
    };

    (function () {

        oop.implement(this, EventEmitter);

        this.add = function (config) {
            if (config.Main)
                oop.mixin(optionGroups.Main, config.Main);
            if (config.More)
                oop.mixin(optionGroups.More, config.More);
        };

        this.render = function () {
            this.container.innerHTML = "";
            buildDom(["table", {
                    role: "presentation",
                    id: "controls"
                },
                this.renderOptionGroup(optionGroups.Main),
                ["tr", null, ["td", {
                        colspan: 2
                    },
                    ["table", {
                            role: "presentation",
                            id: "more-controls"
                        },
                        this.renderOptionGroup(optionGroups.More)
                    ]
                ]],
                ["tr", null, ["td", {
                    colspan: 2
                }, "version " + config.version]]
            ], this.container);
        };

        this.renderOptionGroup = function (group) {
            return Object.keys(group).map(function (key, i) {
                var item = group[key];
                if (!item.position)
                    item.position = i / 10000;
                if (!item.label)
                    item.label = key;
                return item;
            }).sort(function (a, b) {
                return a.position - b.position;
            }).map(function (item) {
                return this.renderOption(item.label, item);
            }, this);
        };

        this.renderOptionControl = function (key, option) {
            var self = this;
            if (Array.isArray(option)) {
                return option.map(function (x) {
                    return self.renderOptionControl(key, x);
                });
            }
            var control;

            var value = self.getOption(option);

            if (option.values && option.type != "checkbox") {
                if (typeof option.values == "string")
                    option.values = option.values.split("|");
                option.items = option.values.map(function (v) {
                    return {
                        value: v,
                        name: v
                    };
                });
            }

            if (option.type == "buttonBar") {
                control = ["div", {
                    role: "group",
                    "aria-labelledby": option.path + "-label"
                }, option.items.map(function (item) {
                    return ["button", {
                        value: item.value,
                        ace_selected_button: value == item.value,
                        'aria-pressed': value == item.value,
                        onclick: function () {
                            self.setOption(option, item.value);
                            var nodes = this.parentNode.querySelectorAll("[ace_selected_button]");
                            for (var i = 0; i < nodes.length; i++) {
                                nodes[i].removeAttribute("ace_selected_button");
                                nodes[i].setAttribute("aria-pressed", false);
                            }
                            this.setAttribute("ace_selected_button", true);
                            this.setAttribute("aria-pressed", true);
                        }
                    }, item.desc || item.caption || item.name];
                })];
            } else if (option.type == "number") {
                control = ["input", {
                    type: "number",
                    value: value || option.defaultValue,
                    style: "width:3em",
                    oninput: function () {
                        self.setOption(option, parseInt(this.value));
                    }
                }];
                if (option.ariaLabel) {
                    control[1]["aria-label"] = option.ariaLabel;
                } else {
                    control[1].id = key;
                }
                if (option.defaults) {
                    control = [control, option.defaults.map(function (item) {
                        return ["button", {
                            onclick: function () {
                                var input = this.parentNode.firstChild;
                                input.value = item.value;
                                input.oninput();
                            }
                        }, item.caption];
                    })];
                }
            } else if (option.items) {
                var buildItems = function (items) {
                    return items.map(function (item) {
                        return ["option", {
                            value: item.value || item.name
                        }, item.desc || item.caption || item.name];
                    });
                };

                var items = Array.isArray(option.items) ?
                    buildItems(option.items) :
                    Object.keys(option.items).map(function (key) {
                        return ["optgroup", {
                            "label": key
                        }, buildItems(option.items[key])];
                    });
                control = ["select", {
                    id: key,
                    value: value,
                    onchange: function () {
                        self.setOption(option, this.value);
                    }
                }, items];
            } else {
                if (typeof option.values == "string")
                    option.values = option.values.split("|");
                if (option.values) value = value == option.values[1];
                control = ["input", {
                    type: "checkbox",
                    id: key,
                    checked: value || null,
                    onchange: function () {
                        var value = this.checked;
                        if (option.values) value = option.values[value ? 1 : 0];
                        self.setOption(option, value);
                    }
                }];
                if (option.type == "checkedNumber") {
                    control = [control, []];
                }
            }
            return control;
        };

        this.renderOption = function (key, option) {
            if (option.path && !option.onchange && !this.editor.$options[option.path])
                return;
            var path = Array.isArray(option) ? option[0].path : option.path;
            this.options[path] = option;
            var safeKey = "-" + path;
            var safeId = path + "-label";
            var control = this.renderOptionControl(safeKey, option);
            return ["tr", {
                    class: "ace_optionsMenuEntry"
                },
                ["td",
                    ["label", {
                        for: safeKey,
                        id: safeId
                    }, key]
                ],
                ["td", control]
            ];
        };

        this.setOption = function (option, value) {
            if (typeof option == "string")
                option = this.options[option];
            if (value == "false") value = false;
            if (value == "true") value = true;
            if (value == "null") value = null;
            if (value == "undefined") value = undefined;
            if (typeof value == "string" && parseFloat(value).toString() == value)
                value = parseFloat(value);
            if (option.onchange)
                option.onchange(value);
            else if (option.path)
                this.editor.setOption(option.path, value);
            this._signal("setOption", {
                name: option.path,
                value: value
            });
        };

        this.getOption = function (option) {
            if (option.getValue)
                return option.getValue();
            return this.editor.getOption(option.path);
        };

    }).call(OptionPanel.prototype);

    exports.OptionPanel = OptionPanel;

});
(function () {
    window.require(["ace/ext/options"], function (m) {
        if (typeof module == "object" && typeof exports == "object" && module) {
            module.exports = m;
        }
    });
})();